import NProgress from '@/utils/nprogress';
import { getToken } from '@/utils/authToken';
import router from '@/router';
import { usePermissionStore, useUserStore } from '@/store';
import { useRoute } from 'vue-router';

/** 重定向到登录页 */
function redirectToLogin(to, next) {
  const params = new URLSearchParams(to.query);
  const queryString = params.toString();
  const redirect = queryString ? `${to.path}?${queryString}` : to.path;
  next(`/login?redirect=${encodeURIComponent(redirect)}`);
}

/**
 * 编译权限列表为高效检查的结构
 * @param {string[]} permissions 原始权限数组
 * @returns {Object} 编译后的权限结构 { exact: Set, prefix: Set }
 */
function compileAuth(permissions) {
  const exact = new Set();
  const prefix = new Set(); // 存储通配权限的前缀（去掉末尾的:*）

  permissions.forEach((perm) => {
    const normalized = perm.toLowerCase().trim();

    if (normalized.endsWith(':*')) {
      // 通配权限：去掉末尾的":*"后保留前缀层级
      const base = normalized.slice(0, -2);
      prefix.add(base + ':'); // 确保以冒号结尾
    } else {
      // 精确权限
      exact.add(normalized);
    }
  });

  return { exact, prefix };
}

/**
 * 检查用户是否拥有指定权限
 * @param {string} code 需要验证的权限码
 * @param {Object} compiled 编译后的权限结构
 * @returns {boolean} 是否具有权限
 */
function checkAuth(code, compiled) {
  const normalized = code.toLowerCase().trim();

  // 1. 检查精确匹配
  if (compiled.exact.has(normalized)) {
    return true;
  }

  // 2. 提取权限层级基础路径
  const lastColonIndex = normalized.lastIndexOf(':');
  if (lastColonIndex === -1) {
    return false; // 无层级结构
  }
  const basePath = normalized.slice(0, lastColonIndex + 1); // 包含结尾冒号

  // 3. 检查通配符权限
  return compiled.prefix.has(basePath);
}

// 路由守卫
export function setupPermission() {
  // 白名单路由
  const whiteList = ['/login', '/install'];
  // 自动导入所有视图组件
  router.beforeEach(async (to, from, next) => {
    NProgress.start();
    const isLogin = !!getToken();
    if (isLogin) {
      if (to.path === '/login') {
        next({ path: '/' });
        NProgress.done();
      } else {
        const permissionStore = usePermissionStore();
        if (permissionStore.isRouteGenerated) {
          console.log('[Plugins.permission.js] 动态路由已存在');
          next();
        } else {
          console.log('[Plugins.permission.js] 开始载入动态路由');
          try {
            const accessibleRoutes = await permissionStore.generateRoutes(
              to.query.nolayout === '1',
            );
            accessibleRoutes.forEach((route) => router.addRoute(route));
            next({ ...to, replace: true });
          } catch (error) {
            const userStore = useUserStore();
            await userStore.clearUserSession();
            redirectToLogin(to, next);
            NProgress.done();
          }
        }
      }
    } else {
      if (whiteList.includes(to.path)) {
        next();
      } else {
        redirectToLogin(to, next);
        NProgress.done();
      }
    }
  });

  router.afterEach(() => {
    NProgress.done();
  });
}

/** 判断是否有权限 */
export function hasAuth(value) {
  const { userInfo } = useUserStore();
  const { perms } = userInfo;
  // 检查权限
  if (typeof value === 'string') {
    // 单个权限表达式
    return checkAuth(value, compileAuth(perms));
  } else if (Array.isArray(value)) {
    // 多个权限表达式，只要有一个适配就可以 或(OR)"逻辑
    return value.some((perm) => checkAuth(perm, compileAuth(perms)));
  }
}
